import { computed } from 'vue'
import { useQuasar } from 'quasar'
import { useChatStore } from '../stores/chat'
import { calculateUnreadCount, hasNewMessages as hasNewMessagesUtil } from '../utils/unread-messages'

export interface RecentChatListProps {
  searchQuery: string
  filteredContent: Array<{ 
    id: string
    name: string
    chat_id?: string
    chat_type?: number
    member_count?: number
    sequence?: number
    read_sequence?: number
  }>
  currentTargetId: string | null
  getLastMessageTime: (id: string, chatType?: number) => string
  getLastMessagePreview: (id: string, chatType?: number) => string
}

export interface RecentChatListEmits {
  'update:searchQuery': [value: string]
  'select-user': [userId: string]
  'select-group': [groupId: string, groupName?: string]
  'delete-chat': [chatId: string, userId: string]
  'view-group-members': [groupId: string]
  'add-friend-from-group': [groupId: string]
}

export function useRecentChatList(
  props: RecentChatListProps,
  emit: (event: any, ...args: any[]) => void
) {
  const $q = useQuasar()
  const chatStore = useChatStore()

  // 判断是否为群组：以 chat_type === 2 为主判断，人数只能作为辅助
  // 重要：不能以人数超过2人为准，还是要以 chat_type 是 2 为主
  // 原因：有可能开始拉群人数超过2个人，后面群主把人员移除群聊，这个群就剩下他一个人
  // 如果以人数判断，就会有bug
  const isGroup = (user: { chat_type?: number; member_count?: number }) => {
    // 优先根据 chat_type 判断：chat_type === 2 为群组
    if (user.chat_type !== undefined && user.chat_type !== null) {
      return user.chat_type === 2
    }
    // 如果没有 chat_type 信息，使用成员数作为辅助判断（向后兼容）
    // 但这种情况应该很少见，因为正常情况下应该有 chat_type
    if (user.member_count !== undefined && user.member_count !== null) {
      return user.member_count >= 3
    }
    // 默认返回 false（单聊）
    return false
  }

  // 计算未读消息数（使用统一工具函数）
  const getUnreadCount = (user: { 
    id: string
    sequence?: number
    read_sequence?: number
    chat_type?: number
  }): number => {
    const targetId = user.id
    const chatType = user.chat_type || 1
    const readSequence = user.read_sequence
    
    // 如果正在和该用户聊天，检查是否是实时消息（非离线消息）
    const currentTargetId = chatStore.currentTargetId
    if (currentTargetId && currentTargetId === targetId && chatType === 1) {
      // 检查是否有实时接收的新消息（不是离线消息）
      const now = Date.now()
      const recentMessages = chatStore.messages.filter(msg => {
        if (msg.chat_type !== 1 || !msg.isReceived) return false
        
        // 检查消息是否来自当前聊天的用户
        const msgFromId = String(msg.from_user_id || '').trim()
        const targetIdStr = String(targetId).trim()
        if (msgFromId !== targetIdStr) return false
        
        // 检查消息时间戳是否大于 read_sequence（未读消息）
        const msgTimestamp = msg.timestamp_ms || msg.timestamp
        if (readSequence !== undefined && readSequence !== null && readSequence > 0) {
          if (msgTimestamp <= readSequence) return false
        }
        
        // 判断是否是实时消息（距离现在10秒内的消息认为是实时消息）
        const timeDiff = now - msgTimestamp
        const isRealTimeMessage = timeDiff <= 10 * 1000 // 10秒内认为是实时消息
        
        return isRealTimeMessage
      })
      
      // 如果有实时消息，说明正在聊天，不显示未读消息
      if (recentMessages.length > 0) {
        return 0
      }
    }
    
    const count = calculateUnreadCount(
      chatStore.messages,
      targetId,
      chatType,
      readSequence
    )
    
    return count
  }

  // 检查是否有新消息（使用统一工具函数）
  const hasNewMessages = (user: { 
    id: string
    sequence?: number
    read_sequence?: number
    chat_type?: number
  }): boolean => {
    // 如果已经有准确的未读数量（getUnreadCount > 0），不显示红点
    const unreadCount = getUnreadCount(user)
    if (unreadCount > 0) {
      return false // 已经有数字角标，不需要红点
    }
    
    const targetId = user.id
    const chatType = user.chat_type || 1
    const readSequence = user.read_sequence
    
    // 如果正在和该用户聊天，检查是否是实时消息（非离线消息）
    const currentTargetId = chatStore.currentTargetId
    if (currentTargetId && currentTargetId === targetId && chatType === 1) {
      // 检查是否有实时接收的新消息（不是离线消息）
      const now = Date.now()
      const hasRealTimeMessage = chatStore.messages.some(msg => {
        if (msg.chat_type !== 1 || !msg.isReceived) return false
        
        // 检查消息是否来自当前聊天的用户
        const msgFromId = String(msg.from_user_id || '').trim()
        const targetIdStr = String(targetId).trim()
        if (msgFromId !== targetIdStr) return false
        
        // 检查消息时间戳是否大于 read_sequence（未读消息）
        const msgTimestamp = msg.timestamp_ms || msg.timestamp
        if (readSequence !== undefined && readSequence !== null && readSequence > 0) {
          if (msgTimestamp <= readSequence) return false
        }
        
        // 判断是否是实时消息（距离现在10秒内的消息认为是实时消息）
        const timeDiff = now - msgTimestamp
        const isRealTimeMessage = timeDiff <= 10 * 1000 // 10秒内认为是实时消息
        
        return isRealTimeMessage
      })
      
      // 如果有实时消息，说明正在聊天，不显示红点
      if (hasRealTimeMessage) {
        return false
      }
    }
    
    return hasNewMessagesUtil(
      chatStore.messages,
      targetId,
      chatType,
      readSequence
    )
  }

  // 处理选择（区分用户和群组）
  const handleSelect = (user: { id: string; name: string; chat_type?: number }) => {
    if (isGroup(user)) {
      // 群组：传递群组ID和名称
      emit('select-group', user.id, user.name)
    } else {
      // 用户：传递用户ID
      emit('select-user', user.id)
    }
  }

  // 处理右键菜单
  const handleContextMenu = (event: MouseEvent, user: { id: string; name: string; chat_id?: string; chat_type?: number }) => {
    // 如果是群组，右键菜单功能暂时禁用，使用按钮菜单
    if (isGroup(user)) {
      return
    }
    
    // 如果是用户聊天，显示删除确认对话框
    if (user.chat_id) {
      $q.dialog({
        title: '删除聊天',
        message: `确定要删除与 ${user.name} 的聊天记录吗？`,
        cancel: true,
        persistent: true,
      }).onOk(() => {
        emit('delete-chat', user.chat_id!, user.id)
      })
    }
  }

  // 判断是否激活（用于高亮显示）- 处理群组ID的 group_ 前缀问题
  const isActive = (user: { id: string; chat_type?: number }): boolean => {
    if (!props.currentTargetId || !user.id) return false
    
    // 如果是群组，需要标准化ID进行比较（处理 group_ 前缀）
    if (isGroup(user)) {
      // 标准化两个ID：移除 group_ 前缀后比较
      const normalizeId = (id: string): string => {
        return id.replace(/^group_/i, '').trim().toLowerCase()
      }
      const normalizedCurrent = normalizeId(props.currentTargetId)
      const normalizedUser = normalizeId(user.id)
      return normalizedCurrent === normalizedUser || 
             props.currentTargetId === user.id ||
             props.currentTargetId.replace(/^group_/i, '') === user.id ||
             props.currentTargetId === user.id.replace(/^group_/i, '')
    } else {
      // 单聊：直接比较
      return props.currentTargetId === user.id
    }
  }

  return {
    // 方法
    isGroup,
    getUnreadCount,
    hasNewMessages,
    handleSelect,
    handleContextMenu,
    isActive,
  }
}

